{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4222dd9d",
   "metadata": {},
   "source": [
    "# Probability Queue Position Models\n",
    "\n",
    "## Overview\n",
    "\n",
    "Here, we will demonstrate how queue position models affect order fill simulation and, ultimately, the strategy's performance. It is essential for accurate backtesting to find the proper queue position modeling by comparing backtest and real trading results. In this context, we will illustrate comparisons by changing queue position models. By doing this, you can determine the appropriate queue position model that aligns with the backtesting and real trading results.\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "    \n",
    "**Note:** This example is for educational purposes only and demonstrates effective strategies for high-frequency market-making schemes. All backtests are based on a 0.005% rebate, the highest market maker rebate available on Binance Futures. See <a href=\"https://www.binance.com/en/support/announcement/binance-upgrades-usd%E2%93%A2-margined-futures-liquidity-provider-program-2023-04-04-01007356e6514df3811b0c80ab8c83bf\">Binance Upgrades USDⓢ-Margined Futures Liquidity Provider Program</a> for more details.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "629c662e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from numba import njit, uint64\n",
    "from numba.typed import Dict\n",
    "\n",
    "from hftbacktest import (\n",
    "    BacktestAsset,\n",
    "    ROIVectorMarketDepthBacktest,\n",
    "    GTX,\n",
    "    LIMIT,\n",
    "    BUY,\n",
    "    SELL,\n",
    "    BUY_EVENT,\n",
    "    SELL_EVENT,\n",
    "    Recorder\n",
    ")\n",
    "from hftbacktest.stats import LinearAssetRecord\n",
    "\n",
    "@njit(cache=True)\n",
    "def measure_trading_intensity(order_arrival_depth, out):\n",
    "    max_tick = 0\n",
    "    for depth in order_arrival_depth:\n",
    "        if not np.isfinite(depth):\n",
    "            continue\n",
    "        \n",
    "        # Sets the tick index to 0 for the nearest possible best price \n",
    "        # as the order arrival depth in ticks is measured from the mid-price\n",
    "        tick = round(depth / .5) - 1\n",
    "        \n",
    "        # In a fast-moving market, buy trades can occur below the mid-price (and vice versa for sell trades) \n",
    "        # since the mid-price is measured in a previous time-step; \n",
    "        # however, to simplify the problem, we will exclude those cases.\n",
    "        if tick < 0 or tick >= len(out):\n",
    "            continue\n",
    "        \n",
    "        # All of our possible quotes within the order arrival depth, \n",
    "        # excluding those at the same price, are considered executed.\n",
    "        out[:tick] += 1\n",
    "        \n",
    "        max_tick = max(max_tick, tick)\n",
    "    return out[:max_tick]\n",
    "\n",
    "@njit(cache=True)\n",
    "def linear_regression(x, y):\n",
    "    sx = np.sum(x)\n",
    "    sy = np.sum(y)\n",
    "    sx2 = np.sum(x ** 2)\n",
    "    sxy = np.sum(x * y)\n",
    "    w = len(x)\n",
    "    slope = (w * sxy - sx * sy) / (w * sx2 - sx**2)\n",
    "    intercept = (sy - slope * sx) / w\n",
    "    return slope, intercept\n",
    "\n",
    "@njit(cache=True)\n",
    "def compute_coeff_simplified(gamma, delta, A, k):\n",
    "    inv_k = np.divide(1, k)\n",
    "    c1 = inv_k\n",
    "    c2 = np.sqrt(np.divide(gamma * np.exp(1), 2 * A * delta * k))\n",
    "    return c1, c2\n",
    "\n",
    "@njit\n",
    "def gridtrading_glft_mm(hbt, recorder, gamma, order_qty):\n",
    "    asset_no = 0\n",
    "    tick_size = hbt.depth(asset_no).tick_size\n",
    "    \n",
    "    arrival_depth = np.full(30_000_000, np.nan, np.float64)\n",
    "    mid_price_chg = np.full(30_000_000, np.nan, np.float64)\n",
    "\n",
    "    t = 0\n",
    "    prev_mid_price_tick = np.nan\n",
    "    mid_price_tick = np.nan\n",
    "    \n",
    "    tmp = np.zeros(500, np.float64)\n",
    "    ticks = np.arange(len(tmp)) + 0.5\n",
    "    \n",
    "    A = np.nan\n",
    "    k = np.nan\n",
    "    volatility = np.nan\n",
    "    delta = 1\n",
    "    \n",
    "    grid_num = 20\n",
    "    max_position = 50 * order_qty\n",
    "    \n",
    "    # Checks every 100 milliseconds.\n",
    "    while hbt.elapse(100_000_000) == 0:\n",
    "        #--------------------------------------------------------\n",
    "        # Records market order's arrival depth from the mid-price.\n",
    "        if not np.isnan(mid_price_tick):\n",
    "            depth = -np.inf\n",
    "            for last_trade in hbt.last_trades(asset_no):\n",
    "                trade_price_tick = last_trade.px / tick_size\n",
    "                \n",
    "                if last_trade.ev & BUY_EVENT == BUY_EVENT:\n",
    "                    depth = max(trade_price_tick - mid_price_tick, depth)\n",
    "                else:\n",
    "                    depth = max(mid_price_tick - trade_price_tick, depth)\n",
    "            arrival_depth[t] = depth\n",
    "        \n",
    "        hbt.clear_last_trades(asset_no)\n",
    "        hbt.clear_inactive_orders(asset_no)\n",
    "        \n",
    "        depth = hbt.depth(asset_no)\n",
    "        position = hbt.position(asset_no)\n",
    "        orders = hbt.orders(asset_no)\n",
    "\n",
    "        best_bid_tick = depth.best_bid_tick\n",
    "        best_ask_tick = depth.best_ask_tick\n",
    "        \n",
    "        prev_mid_price_tick = mid_price_tick\n",
    "        mid_price_tick = (best_bid_tick + best_ask_tick) / 2.0\n",
    "        \n",
    "        # Records the mid-price change for volatility calculation.\n",
    "        mid_price_chg[t] = mid_price_tick - prev_mid_price_tick\n",
    "        \n",
    "        #--------------------------------------------------------\n",
    "        # Calibrates A, k and calculates the market volatility.\n",
    "        \n",
    "        # Updates A, k, and the volatility every 5-sec.\n",
    "        if t % 50 == 0:\n",
    "            # Window size is 10-minute.\n",
    "            if t >= 6_000 - 1:\n",
    "                # Calibrates A, k\n",
    "                tmp[:] = 0\n",
    "                lambda_ = measure_trading_intensity(arrival_depth[t + 1 - 6_000:t + 1], tmp)\n",
    "                if len(lambda_) > 2:\n",
    "                    lambda_ = lambda_[:70] / 600\n",
    "                    x = ticks[:len(lambda_)]\n",
    "                    y = np.log(lambda_)\n",
    "                    k_, logA = linear_regression(x, y)\n",
    "                    A = np.exp(logA)\n",
    "                    k = -k_\n",
    "           \n",
    "                # Updates the volatility.\n",
    "                volatility = np.nanstd(mid_price_chg[t + 1 - 6_000:t + 1]) * np.sqrt(10)\n",
    "\n",
    "        #--------------------------------------------------------\n",
    "        # Computes bid price and ask price.\n",
    "        \n",
    "        c1, c2 = compute_coeff_simplified(gamma, delta, A, k)\n",
    "        \n",
    "        half_spread_tick = c1 + delta / 2 * c2 * volatility\n",
    "        skew = c2 * volatility\n",
    "        \n",
    "        normalized_position = position / order_qty\n",
    "        \n",
    "        reservation_price_tick = mid_price_tick - skew * normalized_position\n",
    "\n",
    "        bid_price_tick = min(np.round(reservation_price_tick - half_spread_tick), best_bid_tick)\n",
    "        ask_price_tick = max(np.round(reservation_price_tick + half_spread_tick), best_ask_tick)\n",
    "        \n",
    "        bid_price = bid_price_tick * tick_size\n",
    "        ask_price = ask_price_tick * tick_size\n",
    "\n",
    "        grid_interval = max(np.round(half_spread_tick) * tick_size, tick_size)\n",
    "\n",
    "        bid_price = np.floor(bid_price / grid_interval) * grid_interval\n",
    "        ask_price = np.ceil(ask_price / grid_interval) * grid_interval\n",
    "        \n",
    "        #--------------------------------------------------------\n",
    "        # Updates quotes.\n",
    "        \n",
    "        # Creates a new grid for buy orders.\n",
    "        new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
    "        if position < max_position and np.isfinite(bid_price):\n",
    "            for i in range(grid_num):\n",
    "                bid_price_tick = round(bid_price / tick_size)\n",
    "                \n",
    "                # order price in tick is used as order id.\n",
    "                new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
    "                \n",
    "                bid_price -= grid_interval\n",
    "\n",
    "        # Creates a new grid for sell orders.\n",
    "        new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
    "        if position > -max_position and np.isfinite(ask_price):\n",
    "            for i in range(grid_num):\n",
    "                ask_price_tick = round(ask_price / tick_size)\n",
    "                \n",
    "                # order price in tick is used as order id.\n",
    "                new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
    "\n",
    "                ask_price += grid_interval\n",
    "                \n",
    "        order_values = orders.values();\n",
    "        while order_values.has_next():\n",
    "            order = order_values.get()\n",
    "            # Cancels if a working order is not in the new grid.\n",
    "            if order.cancellable:\n",
    "                if (\n",
    "                    (order.side == BUY and order.order_id not in new_bid_orders)\n",
    "                    or (order.side == SELL and order.order_id not in new_ask_orders)\n",
    "                ):\n",
    "                    hbt.cancel(asset_no, order.order_id, False)\n",
    "                    \n",
    "        for order_id, order_price in new_bid_orders.items():\n",
    "            # Posts a new buy order if there is no working order at the price on the new grid.\n",
    "            if order_id not in orders:\n",
    "                hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
    "                \n",
    "        for order_id, order_price in new_ask_orders.items():\n",
    "            # Posts a new sell order if there is no working order at the price on the new grid.\n",
    "            if order_id not in orders:\n",
    "                hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
    "                \n",
    "        #--------------------------------------------------------\n",
    "        # Records variables and stats for analysis.\n",
    "        \n",
    "        t += 1\n",
    "        \n",
    "        if t >= len(arrival_depth) or t >= len(mid_price_chg):\n",
    "            raise Exception\n",
    "        \n",
    "        # Records the current state for stat calculation.\n",
    "        recorder.record(hbt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "04a11dcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def backtest(args):\n",
    "    asset_name, asset_info, model = args\n",
    "\n",
    "    # Obtains the mid-price of the assset to determine the order quantity.\n",
    "    snapshot = np.load('data/{}_20230730_eod.npz'.format(asset_name))['data']\n",
    "    best_bid = max(snapshot[snapshot['ev'] & BUY_EVENT == BUY_EVENT]['px'])\n",
    "    best_ask = min(snapshot[snapshot['ev'] & SELL_EVENT == SELL_EVENT]['px'])\n",
    "    mid_price = (best_bid + best_ask) / 2.0\n",
    "\n",
    "    latency_data = np.concatenate(\n",
    "        [np.load('latency/live_order_latency_{}.npz'.format(date))['data'] for date in range(20230731, 20230732)]\n",
    "    )\n",
    "\n",
    "    asset = (\n",
    "        BacktestAsset()\n",
    "            .data(['data/{}_{}.npz'.format(asset_name, date) for date in range(20230731, 20230732)])\n",
    "            .initial_snapshot('data/{}_20230730_eod.npz'.format(asset_name))\n",
    "            .linear_asset(1.0) \n",
    "            .intp_order_latency(latency_data)\n",
    "            .no_partial_fill_exchange()\n",
    "            .trading_value_fee_model(-0.00005, 0.0007)\n",
    "            .tick_size(asset_info['tick_size'])\n",
    "            .lot_size(asset_info['lot_size'])\n",
    "            .roi_lb(0.0)    \n",
    "            .roi_ub(mid_price * 5)\n",
    "            .last_trades_capacity(10000)\n",
    "    )\n",
    "\n",
    "    if model == 'SquareProbQueueModel':\n",
    "        asset.power_prob_queue_model(2)\n",
    "    elif model == 'LogProbQueueModel2':\n",
    "        asset.log_prob_queue_model2()\n",
    "    elif model == 'PowerProbQueueModel3':\n",
    "        asset.power_prob_queue_model3(3)\n",
    "    else:\n",
    "        raise ValueError\n",
    "\n",
    "\n",
    "    hbt = ROIVectorMarketDepthBacktest([asset])\n",
    "\n",
    "    # Sets the order quantity to be equivalent to a notional value of $100.\n",
    "    order_qty = max(round((100 / mid_price) / asset_info['lot_size']), 1) * asset_info['lot_size']\n",
    "\n",
    "    recorder = Recorder(1, 30_000_000)\n",
    "    \n",
    "    gamma = 0.00005\n",
    "    gridtrading_glft_mm(hbt, recorder.recorder, gamma, order_qty)\n",
    "\n",
    "    hbt.close()\n",
    "\n",
    "    recorder.to_npz('stats/gridtrading_simple_glft_qm_{}_{}.npz'.format(model, asset_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "009d2edd",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "from multiprocessing import Pool\n",
    "import json\n",
    "\n",
    "with open('assets2.json', 'r') as f:\n",
    "    assets = json.load(f)\n",
    "\n",
    "with Pool(16) as p:\n",
    "    print(p.map(backtest, [(k, v, 'SquareProbQueueModel') for k, v in assets.items()]))\n",
    "    \n",
    "with Pool(16) as p:\n",
    "    print(p.map(backtest, [(k, v, 'LogProbQueueModel2') for k, v in assets.items()]))\n",
    "    \n",
    "with Pool(16) as p:\n",
    "    print(p.map(backtest, [(k, v, 'PowerProbQueueModel3') for k, v in assets.items()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "42a8edf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Cumulative Returns (%)')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import polars as pl\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def compute_net_equity(model):\n",
    "    equity_values = {}\n",
    "    sr_values = {}\n",
    "\n",
    "    for asset_name in assets.keys():\n",
    "        data = np.load('stats/gridtrading_simple_glft_qm_{}_{}.npz'.format(model, asset_name))['0']\n",
    "        stats = (\n",
    "            LinearAssetRecord(data)\n",
    "                .resample('5m')\n",
    "                .stats()\n",
    "        )\n",
    "    \n",
    "        equity = stats.entire.with_columns(\n",
    "            (pl.col('equity_wo_fee') - pl.col('fee')).alias('equity')\n",
    "        ).select(['timestamp', 'equity'])\n",
    "    \n",
    "        pnl = equity['equity'].diff()\n",
    "        sr = np.divide(pnl.mean(), pnl.std())\n",
    "\n",
    "        equity_values[asset_name] = equity\n",
    "        sr_values[asset_name] = sr\n",
    "\n",
    "    sr_m = np.nanmean(list(sr_values.values()))\n",
    "    sr_s = np.nanstd(list(sr_values.values()))\n",
    "\n",
    "    asset_number = 0\n",
    "    net_equity = None\n",
    "    for i, (equity, sr) in enumerate(zip(equity_values.values(), sr_values.values())):\n",
    "        # There are some assets that aren't working within this scheme.\n",
    "        # This might be because the order arrivals don't follow a Poisson distribution that this model assumes.\n",
    "        # As a result, it filters out assets whose SR falls outside -0.5 sigma.\n",
    "        if (sr - sr_m) / sr_s > -0.5:\n",
    "            asset_number += 1\n",
    "            if net_equity is None:\n",
    "                net_equity = equity.clone()\n",
    "            else:\n",
    "                net_equity = net_equity.select(\n",
    "                    'timestamp',\n",
    "                    (pl.col('equity') + equity['equity']).alias('equity')\n",
    "                )\n",
    "\n",
    "            if asset_number == 100:\n",
    "                # 5_000 is capital for each trading asset.\n",
    "                return net_equity.with_columns(\n",
    "                    (pl.col('equity') / asset_number / 5_000).alias('equity')\n",
    "                )\n",
    "\n",
    "np.seterr(divide='ignore', invalid='ignore')\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches(10, 3)\n",
    "legend = []\n",
    "\n",
    "for model in ['SquareProbQueueModel', 'LogProbQueueModel2', 'PowerProbQueueModel3']:\n",
    "    net_equity_ = compute_net_equity(model)\n",
    "\n",
    "    pnl = net_equity_['equity'].diff()\n",
    "    # Since the P&L is resampled at a 5-minute interval\n",
    "    sr = pnl.mean() / pnl.std() * np.sqrt(24 * 60 / 5)\n",
    "    legend.append('100 assets, Daily SR={:.2f}, {}'.format(sr, model))\n",
    "    plt.plot(net_equity_['timestamp'], net_equity_['equity'] * 100)\n",
    "    \n",
    "plt.legend(\n",
    "    legend,\n",
    "    loc='upper center', bbox_to_anchor=(0.5, -0.15),\n",
    "    fancybox=True, shadow=True, ncol=3\n",
    ")\n",
    "\n",
    "plt.grid()\n",
    "plt.ylabel('Cumulative Returns (%)')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}